const fs = require('fs');
const path = require('path');
const { getLogger } = require('../logger');
const logger = getLogger('controllers.sourcemapController');
const { success, error } = require('../utils/response');

// sourcemap文件存储路径
const SOURCEMAP_DIR = path.join(__dirname, '../data/sourcemaps');
// JS文件可能的存储路径（用于调试）
const JS_DIR = path.join(__dirname, '../data/js');

/**
 * 获取sourcemap文件
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
const getSourcemap = async (req, res) => {
    try {
        
        // 检查是否处于调试模式
        const isDebugMode = req.query.debug === 'true' || req.headers['x-debug'] === 'true';
        
        if (!isDebugMode) {
            return error(req, res, '调试模式未开启', 403, null);
        }
        
        // 获取请求的文件名
        const filename = req.params.filename;
        
        // 确保文件名只包含合法字符，防止路径遍历攻击
        if (!filename || !/^[a-zA-Z0-9~_\-\.]+\.js\.map$/.test(filename)) {
            return error(req, res, '无效的文件名', 400, null);
        }
        
        // 从请求头获取hash目录
        const hashDir = req.headers['hashpath'];
        
        // 解析文件名，构建目标路径
        let targetPath;
        
        // 如果提供了hashDir，验证其有效性并使用
        if (hashDir) {
            // 验证hashDir只包含合法字符，防止路径遍历攻击
            if (!/^[a-zA-Z0-9～_\-]+$/.test(hashDir)) {
                return error(req, res, '无效的hash目录名', 400, null);
            }
            
            // 构建目标路径
            targetPath = path.join(SOURCEMAP_DIR, hashDir, filename);
            
            // 检查该hash目录下的文件是否存在
            if (!fs.existsSync(path.join(SOURCEMAP_DIR, hashDir))) {
                return error(req, res, `指定的hash目录不存在: ${hashDir}`, 404, null);
            }
        } else {
            // 如果没有提供hashDir，从最新的hash目录中查找
            const hashDirs = fs.readdirSync(SOURCEMAP_DIR).filter(dir => {
                return fs.statSync(path.join(SOURCEMAP_DIR, dir)).isDirectory();
            });
            
            if (hashDirs.length === 0) {
                return error(req, res, '没有找到sourcemap目录', 404, null);
            }
            
            // 按修改时间排序，使用最新的hash目录
            hashDirs.sort((a, b) => {
                const timeA = fs.statSync(path.join(SOURCEMAP_DIR, a)).mtime.getTime();
                const timeB = fs.statSync(path.join(SOURCEMAP_DIR, b)).mtime.getTime();
                return timeB - timeA;
            });
            
            targetPath = path.join(SOURCEMAP_DIR, hashDirs[0], filename);
        }
        // 检查文件是否存在
        if (!fs.existsSync(targetPath)) {
            return error(req, res, 'Sourcemap文件不存在', 404, null);
        }
        
        // 设置正确的MIME类型
        res.setHeader('Content-Type', 'application/json');
        
        // 发送文件
        res.sendFile(targetPath);
    } catch (err) {
        logger.error('获取sourcemap文件失败', { error: err });
        return error(req, res, '服务器内部错误', 500, null);
    }
    

};

/**
 * 检查调试模式状态
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
const checkDebugStatus = async (req, res) => {
    try {
        // 从环境变量或配置中获取调试模式的默认状态
        const defaultDebugEnabled = process.env.ENABLE_SOURCEMAP_DEBUG === 'true';
        // const defaultDebugEnabled = true
        return success(req, res, '调试模式状态检查成功', {
            debugEnabled: defaultDebugEnabled
        });
    } catch (err) {
        logger.error('检查调试状态失败', { error: err });
        return error(req, res, '服务器内部错误', 500, null);
    }
};

module.exports = {
    getSourcemap,
    checkDebugStatus
};